{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Implementing a Neural Network\n",
    "In this exercise we will develop a neural network with fully-connected layers to perform classification, and test it out on the CIFAR-10 dataset.\n",
    "\n",
    "在这个练习中，我们将开发一个具有全连接层的神经网络来执行分类，并在CIFAR-10数据集上进行测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# A bit of setup\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from cs231n.classifiers.neural_net import TwoLayerNet\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "We will use the class `TwoLayerNet` in the file `cs231n/classifiers/neural_net.py` to represent instances of our network. \n",
    "\n",
    "The network parameters are stored in the instance variable `self.params` where keys are string parameter names and values are numpy arrays. \n",
    "\n",
    "Below, we initialize toy data and a toy model that we will use to develop your implementation.\n",
    "\n",
    "我们将使用文件`cs231n/classifiers/neural_net.py`中的类`TwoLayerNet`来表示我们的网络实例。\n",
    "\n",
    "网络参数存储在实例变量`self.params`中。其中键是字符串参数名，值是numpy数组。\n",
    "\n",
    "下面，我们初始化玩具数据和一个玩具模型，我们将使用它来开发您的实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# Create a small net and some toy data to check your implementations.\n",
    "# Note that we set the random seed for repeatable experiments.\n",
    "# 创建一个小网络和一些玩具数据来检查你的实现。\n",
    "# 注意，我们为可重复的实验设置了随机种子。\n",
    "input_size = 4\n",
    "hidden_size = 10\n",
    "num_classes = 3\n",
    "num_inputs = 5\n",
    "\n",
    "def init_toy_model():\n",
    "    np.random.seed(0)\n",
    "    return TwoLayerNet(input_size, hidden_size, num_classes, std=1e-1)\n",
    "\n",
    "def init_toy_data():\n",
    "    np.random.seed(1)\n",
    "    X = 10 * np.random.randn(num_inputs, input_size)\n",
    "    y = np.array([0, 1, 2, 2, 1])\n",
    "    return X, y\n",
    "\n",
    "net = init_toy_model()\n",
    "X, y = init_toy_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forward pass: compute scores\n",
    "Open the file `cs231n/classifiers/neural_net.py` and look at the method `TwoLayerNet.loss`. \n",
    "\n",
    "This function is very similar to the loss functions you have written for the SVM and Softmax exercises: \n",
    "\n",
    "It takes the data and weights and computes the class scores, the loss, and the gradients on the parameters. \n",
    "\n",
    "Implement the first part of the forward pass which uses the weights and biases to compute the scores for all inputs.\n",
    "\n",
    "打开文件`cs231n/classifiers/neural_net.py`看看`TwoLayerNet.loss`方法。\n",
    "\n",
    "这个函数与您为SVM和Softmax练习编写的损失函数非常相似:\n",
    "\n",
    "它获取数据和权重，并计算类分数、损失和参数上的梯度。\n",
    "\n",
    "实现前向传球的第一部分，它使用权重和偏差来计算所有输入的分数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your scores:\n",
      "[[-0.81233741 -1.27654624 -0.70335995]\n",
      " [-0.17129677 -1.18803311 -0.47310444]\n",
      " [-0.51590475 -1.01354314 -0.8504215 ]\n",
      " [-0.15419291 -0.48629638 -0.52901952]\n",
      " [-0.00618733 -0.12435261 -0.15226949]]\n",
      "\n",
      "correct scores:\n",
      "[[-0.81233741 -1.27654624 -0.70335995]\n",
      " [-0.17129677 -1.18803311 -0.47310444]\n",
      " [-0.51590475 -1.01354314 -0.8504215 ]\n",
      " [-0.15419291 -0.48629638 -0.52901952]\n",
      " [-0.00618733 -0.12435261 -0.15226949]]\n",
      "\n",
      "Difference between your scores and correct scores:\n",
      "3.6802720496109664e-08\n"
     ]
    }
   ],
   "source": [
    "scores = net.loss(X)\n",
    "print('Your scores:')\n",
    "print(scores)\n",
    "print()\n",
    "print('correct scores:')\n",
    "correct_scores = np.asarray([\n",
    "  [-0.81233741, -1.27654624, -0.70335995],\n",
    "  [-0.17129677, -1.18803311, -0.47310444],\n",
    "  [-0.51590475, -1.01354314, -0.8504215 ],\n",
    "  [-0.15419291, -0.48629638, -0.52901952],\n",
    "  [-0.00618733, -0.12435261, -0.15226949]])\n",
    "print(correct_scores)\n",
    "print()\n",
    "\n",
    "# The difference should be very small. We get < 1e-7\n",
    "print('Difference between your scores and correct scores:')\n",
    "print(np.sum(np.abs(scores - correct_scores)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forward pass: compute loss\n",
    "In the same function, implement the second part that computes the data and regularization loss.\n",
    "\n",
    "在同一个函数中，实现了计算数据和正则化损失的第二部分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference between your loss and correct loss:\n",
      "0.01896541960606335\n"
     ]
    }
   ],
   "source": [
    "loss, _ = net.loss(X, y, reg=0.05)\n",
    "correct_loss = 1.30378789133\n",
    "\n",
    "# should be very small, we get < 1e-12\n",
    "print('Difference between your loss and correct loss:')\n",
    "print(np.sum(np.abs(loss - correct_loss)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Backward pass\n",
    "Implement the rest of the function. \n",
    "\n",
    "This will compute the gradient of the loss with respect to the variables `W1`, `b1`, `W2`, and `b2`. \n",
    "\n",
    "Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check:\n",
    "\n",
    "实现函数的其余部分。\n",
    "\n",
    "这将计算出损失对变量`W1`, `b1`, `W2`, and `b2`的梯度。\n",
    "\n",
    "现在你(希望!)有一个正确实现的前向通过，你可以调试你的后向通过使用一个数字梯度检查:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W2 max relative error: 3.440708e-09\n",
      "b2 max relative error: 3.865091e-11\n",
      "W1 max relative error: 3.561318e-09\n",
      "b1 max relative error: 1.555470e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.gradient_check import eval_numerical_gradient\n",
    "\n",
    "# Use numeric gradient checking to check your implementation of the backward pass.\n",
    "# If your implementation is correct, the difference between the numeric and\n",
    "# analytic gradients should be less than 1e-8 for each of W1, W2, b1, and b2.\n",
    "# 使用数值渐变检查来检查后向遍历的实现。\n",
    "# 如果您的实现是正确的，那么对于W1、W2、b1和b2，数值梯度和解析梯度之间的差异应该小于1e-8。\n",
    "loss, grads = net.loss(X, y, reg=0.05)\n",
    "\n",
    "# these should all be less than 1e-8 or so\n",
    "for param_name in grads:\n",
    "    f = lambda W: net.loss(X, y, reg=0.05)[0]\n",
    "    param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=False)\n",
    "    print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train the network\n",
    "To train the network we will use stochastic gradient descent (SGD), similar to the SVM and Softmax classifiers. \n",
    "\n",
    "Look at the function `TwoLayerNet.train` and fill in the missing sections to implement the training procedure. \n",
    "\n",
    "This should be very similar to the training procedure you used for the SVM and Softmax classifiers. \n",
    "\n",
    "You will also have to implement `TwoLayerNet.predict`, as the training process periodically performs prediction to keep track of accuracy over time while the network trains.\n",
    "\n",
    "为了训练网络，我们将使用随机梯度下降法(SGD)，类似于SVM和Softmax分类器。\n",
    "\n",
    "看看`TwoLayerNet.train`函数，并填写缺失的部分，以实现训练程序。\n",
    "\n",
    "这应该与SVM和Softmax分类器的训练过程非常相似。\n",
    "\n",
    "您还必须实现`TwoLayerNet.predict`，因为在网络训练的过程中，训练过程会周期性地进行预测，以跟踪一段时间内的准确性。\n",
    "\n",
    "\n",
    "Once you have implemented the method, run the code below to train a two-layer network on toy data. \n",
    "\n",
    "You should achieve a training loss less than 0.02.\n",
    "\n",
    "一旦你实现了这个方法，运行下面的代码在玩具数据上训练一个两层网络。\n",
    "\n",
    "你的训练损失应该少于0.02。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final training loss:  0.01714364353292376\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "net = init_toy_model()\n",
    "stats = net.train(X, y, X, y,\n",
    "            learning_rate=1e-1, reg=5e-6,\n",
    "            num_iters=100, verbose=False)\n",
    "\n",
    "print('Final training loss: ', stats['loss_history'][-1])\n",
    "\n",
    "# plot the loss history\n",
    "plt.plot(stats['loss_history'])\n",
    "plt.xlabel('iteration')\n",
    "plt.ylabel('training loss')\n",
    "plt.title('Training Loss history')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the data\n",
    "Now that you have implemented a two-layer network that passes gradient checks and works on toy data, it's time to load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset.\n",
    "\n",
    "现在您已经实现了一个两层的网络，它可以通过渐变检查并处理玩具数据，现在是时候加载我们最喜欢的CIFAR-10数据了，这样我们就可以使用它来训练真实数据集上的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3072)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3072)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3072)\n",
      "Test labels shape:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "from cs231n.data_utils import load_CIFAR10\n",
    "\n",
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the two-layer neural net classifier. These are the same steps as\n",
    "    we used for the SVM, but condensed to a single function.  \n",
    "    从磁盘加载CIFAR-10数据集并执行预处理，为两层神经网络分类器做好准备。\n",
    "    这些步骤与我们在SVM中使用的步骤相同，但是被压缩为一个函数。\n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "#     cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    cifar10_dir = 'E:\\cifar-10-batches-py'\n",
    "\n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "        \n",
    "    # Subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "\n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis=0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "\n",
    "    # Reshape data to rows\n",
    "    X_train = X_train.reshape(num_training, -1)\n",
    "    X_val = X_val.reshape(num_validation, -1)\n",
    "    X_test = X_test.reshape(num_test, -1)\n",
    "\n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a network\n",
    "To train our network we will use SGD. \n",
    "\n",
    "In addition, we will adjust the learning rate with an exponential learning rate schedule as optimization proceeds; \n",
    "\n",
    "after each epoch, we will reduce the learning rate by multiplying it by a decay rate.\n",
    "\n",
    "为了训练我们的网络，我们将使用SGD。\n",
    "\n",
    "此外，随着优化的进行，我们将采用指数学习速率计划来调整学习速率;\n",
    "\n",
    "在每个epoch之后，我们将通过将其乘以衰减率来降低学习率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1000: loss 2.302762\n",
      "iteration 100 / 1000: loss 2.302358\n",
      "iteration 200 / 1000: loss 2.297404\n",
      "iteration 300 / 1000: loss 2.258897\n",
      "iteration 400 / 1000: loss 2.202975\n",
      "iteration 500 / 1000: loss 2.116816\n",
      "iteration 600 / 1000: loss 2.049789\n",
      "iteration 700 / 1000: loss 1.985711\n",
      "iteration 800 / 1000: loss 2.003726\n",
      "iteration 900 / 1000: loss 1.948076\n",
      "Validation accuracy:  0.287\n"
     ]
    }
   ],
   "source": [
    "input_size = 32 * 32 * 3\n",
    "hidden_size = 50\n",
    "num_classes = 10\n",
    "net = TwoLayerNet(input_size, hidden_size, num_classes)\n",
    "\n",
    "# Train the network\n",
    "stats = net.train(X_train, y_train, X_val, y_val,\n",
    "            num_iters=1000, batch_size=200,\n",
    "            learning_rate=1e-4, learning_rate_decay=0.95,\n",
    "            reg=0.25, verbose=True)\n",
    "\n",
    "# Predict on the validation set\n",
    "val_acc = (net.predict(X_val) == y_val).mean()\n",
    "print('Validation accuracy: ', val_acc)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Debug the training\n",
    "With the default parameters we provided above, you should get a validation accuracy of about 0.29 on the validation set. This isn't very good.\n",
    "\n",
    "One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.\n",
    "\n",
    "Another strategy is to visualize the weights that were learned in the first layer of the network. \n",
    "\n",
    "In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized.\n",
    "\n",
    "使用上面提供的默认参数，验证集的验证精度应该在0.29左右。这不是很好。\n",
    "\n",
    "了解问题所在的一种策略是，在优化过程中绘制损失函数和训练集和验证集的准确性。\n",
    "\n",
    "另一种策略是将在网络的第一层学到的权重可视化。\n",
    "\n",
    "在大多数以视觉数据为训练对象的神经网络中，第一层的权值在可视化时通常会显示一些可见的结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the loss function and train / validation accuracies\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(stats['loss_history'])\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(stats['train_acc_history'], label='train')\n",
    "plt.plot(stats['val_acc_history'], label='val')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Classification accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from cs231n.vis_utils import visualize_grid\n",
    "\n",
    "# Visualize the weights of the network\n",
    "\n",
    "def show_net_weights(net):\n",
    "    W1 = net.params['W1']\n",
    "    W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)\n",
    "    plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))\n",
    "    plt.gca().axis('off')\n",
    "    plt.show()\n",
    "\n",
    "show_net_weights(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tune your hyperparameters\n",
    "\n",
    "**What's wrong?**. \n",
    "\n",
    "Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. \n",
    "\n",
    "Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. \n",
    "\n",
    "On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.\n",
    "\n",
    "**怎么了?**\n",
    "\n",
    "看看上面的可视化，我们可以看到损失或多或少是线性减少的，这似乎表明**学习率**可能太低了。\n",
    "\n",
    "此外，训练的准确性和验证的准确性之间没有差距，这说明我们使用的**模型容量**较低，我们应该增加模型的大小。\n",
    "\n",
    "另一方面，对于一个非常大的模型，我们期望看到更多的**过拟合**，这将表现为训练和验证准确性之间的一个非常大的差距。\n",
    "\n",
    "\n",
    "**Tuning**. \n",
    "\n",
    "Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. \n",
    "\n",
    "Below, you should experiment with different values of the various hyperparameters, including **hidden layer size**, **learning rate**, **numer of training epochs**, and **regularization strength**. \n",
    "\n",
    "You might also consider tuning **the learning rate decay**, but you should be able to get good performance using the default value.\n",
    "\n",
    "**调优**\n",
    "\n",
    "调整超参数并开发它们如何影响最终性能的直觉是使用神经网络的一个重要部分，因此我们希望您进行大量实践。\n",
    "\n",
    "下面，您应该试验各种超参数的不同值，包括**隐层大小**、**学习率**、**训练周期数**和**正则化强度**。\n",
    "\n",
    "您也可以考虑调优**学习速率衰减**，但是您应该能够使用默认值获得良好的性能。\n",
    "\n",
    "\n",
    "**Approximate results**. \n",
    "\n",
    "You should be aim to achieve a classification accuracy of greater than 48% on **the validation set**. \n",
    "\n",
    "Our best network gets over 52% on **the validation set**.\n",
    "\n",
    "**近似的结果**\n",
    "\n",
    "您的目标应该是在验证集上获得超过48%的分类准确率。\n",
    "\n",
    "我们最好的网络在验证集上获得超过52%的准确率。\n",
    "\n",
    "\n",
    "**Experiment**: \n",
    "\n",
    "You goal in this exercise is to get as good of a result on CIFAR-10 as you can (52% could serve as a reference), with a fully-connected Neural Network. \n",
    "\n",
    "Feel free implement your own techniques (e.g. PCA to reduce dimensionality, or adding dropout, or adding features to the solver, etc.).\n",
    "\n",
    "**实验**:\n",
    "\n",
    "在这个练习中，您的目标是使用一个全连接的神经网络，在CIFAR-10上获得尽可能好的结果(52%可以作为参考)。\n",
    "\n",
    "您可以自由地实现自己的技术(例如，使用PCA来降低维度，或添加dropout，或向求解器添加特性，等等)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Explain your hyperparameter tuning process below.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      ".\n",
      "\n",
      "finshed\n",
      "hidden size 75 learning rates 7.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.469000\n",
      "hidden size 75 learning rates 7.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.485000\n",
      "hidden size 75 learning rates 7.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.468000\n",
      "hidden size 75 learning rates 8.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.485000\n",
      "hidden size 75 learning rates 8.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.484000\n",
      "hidden size 75 learning rates 8.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.465000\n",
      "hidden size 75 learning rates 9.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.482000\n",
      "hidden size 75 learning rates 9.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.485000\n",
      "hidden size 75 learning rates 9.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.496000\n",
      "hidden size 75 learning rates 1.000000e-03 regularization strengths 7.500000e-01 validation accuracy: 0.493000\n",
      "hidden size 75 learning rates 1.000000e-03 regularization strengths 1.000000e+00 validation accuracy: 0.487000\n",
      "hidden size 75 learning rates 1.000000e-03 regularization strengths 1.250000e+00 validation accuracy: 0.479000\n",
      "hidden size 75 learning rates 1.100000e-03 regularization strengths 7.500000e-01 validation accuracy: 0.492000\n",
      "hidden size 75 learning rates 1.100000e-03 regularization strengths 1.000000e+00 validation accuracy: 0.482000\n",
      "hidden size 75 learning rates 1.100000e-03 regularization strengths 1.250000e+00 validation accuracy: 0.465000\n",
      "hidden size 100 learning rates 7.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.476000\n",
      "hidden size 100 learning rates 7.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.473000\n",
      "hidden size 100 learning rates 7.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.478000\n",
      "hidden size 100 learning rates 8.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.487000\n",
      "hidden size 100 learning rates 8.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.491000\n",
      "hidden size 100 learning rates 8.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.487000\n",
      "hidden size 100 learning rates 9.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.485000\n",
      "hidden size 100 learning rates 9.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.488000\n",
      "hidden size 100 learning rates 9.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.493000\n",
      "hidden size 100 learning rates 1.000000e-03 regularization strengths 7.500000e-01 validation accuracy: 0.496000\n",
      "hidden size 100 learning rates 1.000000e-03 regularization strengths 1.000000e+00 validation accuracy: 0.494000\n",
      "hidden size 100 learning rates 1.000000e-03 regularization strengths 1.250000e+00 validation accuracy: 0.484000\n",
      "hidden size 100 learning rates 1.100000e-03 regularization strengths 7.500000e-01 validation accuracy: 0.502000\n",
      "hidden size 100 learning rates 1.100000e-03 regularization strengths 1.000000e+00 validation accuracy: 0.483000\n",
      "hidden size 100 learning rates 1.100000e-03 regularization strengths 1.250000e+00 validation accuracy: 0.496000\n",
      "hidden size 125 learning rates 7.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.469000\n",
      "hidden size 125 learning rates 7.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.478000\n",
      "hidden size 125 learning rates 7.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.471000\n",
      "hidden size 125 learning rates 8.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.498000\n",
      "hidden size 125 learning rates 8.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.491000\n",
      "hidden size 125 learning rates 8.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.497000\n",
      "hidden size 125 learning rates 9.000000e-04 regularization strengths 7.500000e-01 validation accuracy: 0.486000\n",
      "hidden size 125 learning rates 9.000000e-04 regularization strengths 1.000000e+00 validation accuracy: 0.491000\n",
      "hidden size 125 learning rates 9.000000e-04 regularization strengths 1.250000e+00 validation accuracy: 0.483000\n",
      "hidden size 125 learning rates 1.000000e-03 regularization strengths 7.500000e-01 validation accuracy: 0.500000\n",
      "hidden size 125 learning rates 1.000000e-03 regularization strengths 1.000000e+00 validation accuracy: 0.483000\n",
      "hidden size 125 learning rates 1.000000e-03 regularization strengths 1.250000e+00 validation accuracy: 0.490000\n",
      "hidden size 125 learning rates 1.100000e-03 regularization strengths 7.500000e-01 validation accuracy: 0.500000\n",
      "hidden size 125 learning rates 1.100000e-03 regularization strengths 1.000000e+00 validation accuracy: 0.477000\n",
      "hidden size 125 learning rates 1.100000e-03 regularization strengths 1.250000e+00 validation accuracy: 0.470000\n",
      "best validation accuracy achieved during cross-validation: 0.502000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nimport random\\nX_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\\nworkers=2\\ninput_size = 32 * 32 * 3\\nnum_classes = 10\\nbest_accuracy=0\\nfor worki in range(0,workers):\\n    hidden_size=random.randint(110,130)\\n    learning_ratei = 10 ** np.random.uniform(-5,-3)\\n    #0.0000992918\\n    numer_of_training_epochs =random.randint(500,2000)\\n    reg =0.25\\n\\n    net = TwoLayerNet(input_size, hidden_size, num_classes)\\n    # Train the network\\n    stats = net.train(X_train, y_train, X_val, y_val,\\n                num_iters=numer_of_training_epochs, batch_size=200,\\n                learning_rate=learning_ratei, learning_rate_decay=0.95,\\n                reg=reg, verbose=True)\\n    \\n    val_acc = (net.predict(X_val) == y_val).mean()\\n    print(\"hidden_size:%d ,learning_rate:%.10lf ,numer_of_training_epochs:%d ,reg:%.10lf\\n val_acc:%.10lf\\n\"\\n          %(hidden_size,learning_ratei,numer_of_training_epochs,reg,val_acc))\\n    \\n    if val_acc>best_accuracy:\\n        best_accuracy=val_acc\\n        best_net=net\\nprint(\"Best accuracy is: %.10lf\\n\"%best_accuracy)\\n'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_net = None # store the best model into this \n",
    "\n",
    "#################################################################################\n",
    "# TODO: Tune hyperparameters using the validation set. Store your best trained  #\n",
    "# model in best_net.                                                            #\n",
    "#                                                                               #\n",
    "# To help debug your network, it may help to use visualizations similar to the  #\n",
    "# ones we used above; these visualizations will have significant qualitative    #\n",
    "# differences from the ones we saw above for the poorly tuned network.          #\n",
    "#                                                                               #\n",
    "# Tweaking hyperparameters by hand can be fun, but you might find it useful to  #\n",
    "# write code to sweep through possible combinations of hyperparameters          #\n",
    "# automatically like we did on the previous exercises.                          #\n",
    "#################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# 使用验证集调整超参数。\n",
    "# 将您的最佳训练模型存储在best_net中。\n",
    "# 为了帮助调试你的网络，使用类似于我们上面所使用的可视化可能会有所帮助;\n",
    "# 这些可视化将与我们在上面看到的那些不太协调的网络在质量上有显著的不同。\n",
    "# 手工调整超参数可能很有趣，但是您可能会发现编写代码自动扫描可能的超参数组合很有用，\n",
    "# 就像我们在前面的练习中所做的那样。\n",
    "pass\n",
    "\n",
    "results = {}\n",
    "best_val_acc = 0\n",
    "best_net = None\n",
    "# 原来的超参数\n",
    "# hidden layer size# hidden_size = 50  太小\n",
    "# learning rate# learning_rate=1e-4 太小\n",
    "# numer of training epochs# num_iters=1000\n",
    "# regularization strength# reg=0.25\n",
    "# learning_rate_decay=0.95\n",
    "hidden_size = [75, 100, 125]\n",
    "learning_rates = np.array([0.7, 0.8, 0.9, 1, 1.1])*1e-3\n",
    "regularization_strengths = [0.75, 1, 1.25]\n",
    "\n",
    "print('running')\n",
    "for hs in hidden_size:\n",
    "    for lr in learning_rates:\n",
    "        for reg in regularization_strengths:\n",
    "            print('.')\n",
    "            net = TwoLayerNet(input_size, hs, num_classes)\n",
    "            # Train the network\n",
    "            stats = net.train(X_train, y_train, X_val, y_val,\n",
    "                            num_iters=1500, batch_size=200,\n",
    "                            learning_rate=lr, learning_rate_decay=0.95,\n",
    "                            reg= reg, verbose=False)\n",
    "            val_acc = (net.predict(X_val) == y_val).mean()\n",
    "            if val_acc > best_val_acc:\n",
    "                best_val_acc = val_acc\n",
    "                best_net = net         \n",
    "            results[(hs,lr,reg)] = val_acc\n",
    "print()\n",
    "print(\"finshed\")\n",
    "# Print out results.\n",
    "for hs,lr,reg in sorted(results):\n",
    "    val_acc = results[(hs, lr, reg)]\n",
    "    print('hidden size %d learning rates %e regularization strengths %e validation accuracy: %f' \n",
    "          % (hs, lr, reg,  val_acc))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val_acc)\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "import random\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\n",
    "workers=2\n",
    "input_size = 32 * 32 * 3\n",
    "num_classes = 10\n",
    "best_accuracy=0\n",
    "for worki in range(0,workers):\n",
    "    hidden_size=random.randint(110,130)\n",
    "    learning_ratei = 10 ** np.random.uniform(-5,-3)\n",
    "    #0.0000992918\n",
    "    numer_of_training_epochs =random.randint(500,2000)\n",
    "    reg =0.25\n",
    "\n",
    "    net = TwoLayerNet(input_size, hidden_size, num_classes)\n",
    "    # Train the network\n",
    "    stats = net.train(X_train, y_train, X_val, y_val,\n",
    "                num_iters=numer_of_training_epochs, batch_size=200,\n",
    "                learning_rate=learning_ratei, learning_rate_decay=0.95,\n",
    "                reg=reg, verbose=True)\n",
    "    \n",
    "    val_acc = (net.predict(X_val) == y_val).mean()\n",
    "    print(\"hidden_size:%d ,learning_rate:%.10lf ,numer_of_training_epochs:%d ,reg:%.10lf\\n val_acc:%.10lf\\n\"\n",
    "          %(hidden_size,learning_ratei,numer_of_training_epochs,reg,val_acc))\n",
    "    \n",
    "    if val_acc>best_accuracy:\n",
    "        best_accuracy=val_acc\n",
    "        best_net=net\n",
    "print(\"Best accuracy is: %.10lf\\n\"%best_accuracy)\n",
    "'''\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize the weights of the best network\n",
    "show_net_weights(best_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run on the test set\n",
    "When you are done experimenting, you should evaluate your final trained network on the test set; \n",
    "\n",
    "you should get above 48%.\n",
    "\n",
    "当你完成实验时，你应该在测试集上评估你最终的训练网络;你应该得到48%以上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy:  0.502\n"
     ]
    }
   ],
   "source": [
    "test_acc = (best_net.predict(X_test) == y_test).mean()\n",
    "print('Test accuracy: ', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question**\n",
    "\n",
    "Now that you have trained a Neural Network classifier, you may find that your testing accuracy is much lower than the training accuracy. \n",
    "\n",
    "In what ways can we decrease this gap? Select all that apply.\n",
    "\n",
    "现在您已经训练了一个神经网络分类器，您可能会发现您的测试精度远远低于训练精度。\n",
    "\n",
    "我们可以用什么方法来缩小这种差距?选择所有应用。\n",
    "\n",
    "1. Train on a larger dataset.\n",
    "2. Add more hidden units.\n",
    "3. Increase the regularization strength.\n",
    "4. None of the above.\n",
    "\n",
    "\n",
    "1. 在更大的数据集上进行训练。\n",
    "2. 添加更多隐藏单元。\n",
    "3. 增加正则化强度。\n",
    "4. 以上皆非。\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# print('1')\n",
    "# print()\n",
    "# print('1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
